home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / gfx / show / svoUtah22.lha / svoUtahRLE / source / URT / lib / rle_row_alc.c < prev    next >
C/C++ Source or Header  |  1990-08-02  |  4KB  |  137 lines
  1. /*
  2.  * This software is copyrighted as noted below.  It may be freely copied,
  3.  * modified, and redistributed, provided that the copyright notice is 
  4.  * preserved on all copies.
  5.  * 
  6.  * There is no warranty or other guarantee of fitness for this software,
  7.  * it is provided solely "as is".  Bug reports or fixes may be sent
  8.  * to the author, who may or may not act on them as he desires.
  9.  *
  10.  * You may not include this software in a program or other software product
  11.  * without supplying the source, or without informing the end-user that the 
  12.  * source is available for no extra charge.
  13.  *
  14.  * If you modify this software, you should include a notice giving the
  15.  * name of the person performing the modification, the date of modification,
  16.  * and the reason for such modification.
  17.  *
  18.  *  Modified at BRL 16-May-88 by Mike Muuss to avoid Alliant STDC desire
  19.  *  to have all "void" functions so declared.
  20.  */
  21. /* 
  22.  * rle_row_alc.c - Allocate buffers for rle_getrow/rle_putrow.
  23.  * 
  24.  * Author:    Spencer W. Thomas
  25.  *         Computer Science Dept.
  26.  *         University of Utah
  27.  * Date:    Fri Nov 14 1986
  28.  * Copyright (c) 1986, Spencer W. Thomas
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include <rle.h>
  33.  
  34. #ifndef VOID_STAR
  35. extern char * malloc();
  36. #else
  37. extern void *malloc();
  38. #endif
  39. extern void free();
  40.  
  41. /*****************************************************************
  42.  * TAG( rle_row_alloc )
  43.  * 
  44.  * Allocate buffer space for use by rle_getrow and rle_putrow.
  45.  * Inputs:
  46.  *     the_hdr:    Header structure for RLE file to be read or
  47.  *            written.
  48.  * Outputs:
  49.  *    scanp:        Pointer to pointer to created scanline buffer.
  50.  *            This pointer is adjusted for the alpha channel,
  51.  *            if present.
  52.  *    Returns 0 for success, -1 if malloc failed.
  53.  * Assumptions:
  54.  *     No input scanline will extend beyond the declared xmax endpoint.
  55.  * Algorithm:
  56.  *    Count number of channels actually used (check bitmap).
  57.  *     Allocate nchan*rowlength pixels, allocate a buffer
  58.  *    to hold ncolors+alpha pointers, and give each channel
  59.  *    rowlength pixels.  Rowlength is xmax + 1, to allow for rle_getrow
  60.  *    usage.
  61.  */
  62. int
  63. rle_row_alloc( the_hdr, scanp )
  64. rle_hdr *the_hdr;
  65. rle_pixel ***scanp;
  66. {
  67.     rle_pixel ** scanbuf, * pixbuf;
  68.     int rowlen, nchan = 0, i, ncol;
  69.  
  70.     rowlen = the_hdr->xmax + 1;
  71.     if ( the_hdr->alpha && RLE_BIT( *the_hdr, RLE_ALPHA ) )
  72.     nchan++;
  73.     for ( i = 0; i < the_hdr->ncolors; i++ )
  74.     if ( RLE_BIT( *the_hdr, i ) )
  75.          nchan++;
  76.  
  77.     ncol = the_hdr->ncolors + the_hdr->alpha;
  78.  
  79.     if ( (scanbuf = (rle_pixel **)malloc( ncol * sizeof(rle_pixel *) )) == 0 )
  80.     return -1;
  81.     if ( (pixbuf = (rle_pixel *)malloc( nchan * rowlen *
  82.                        sizeof(rle_pixel) )) == 0 )
  83.     {
  84.     free( scanbuf );
  85.     return -1;
  86.     }
  87.  
  88.     if ( the_hdr->alpha )
  89.     scanbuf++;
  90.  
  91.     for ( i = -the_hdr->alpha; i < the_hdr->ncolors; i++ )
  92.     if ( RLE_BIT( *the_hdr, i ) )
  93.     {
  94.         scanbuf[i] = pixbuf;
  95.         pixbuf += rowlen;
  96.     }
  97.     else
  98.         scanbuf[i] = 0;
  99.     *scanp = scanbuf;
  100.  
  101.     return 0;
  102. }
  103.  
  104.  
  105. /*****************************************************************
  106.  * TAG( rle_row_free )
  107.  * 
  108.  * Free storage allocated by rle_row_alloc().
  109.  * Inputs:
  110.  *     the_hdr:    Header structure as above.
  111.  *    scanp:        Pointer to scanbuf above.
  112.  * Outputs:
  113.  *     Frees storage referenced by scanp and nrawp.
  114.  * Assumptions:
  115.  *     Storage was allocated by rle_row_alloc, or by use of same
  116.  *    algorithm, at least.
  117.  * Algorithm:
  118.  *     free scanp[0] and scanp.
  119.  */
  120. void
  121. rle_row_free( the_hdr, scanp )
  122. rle_hdr *the_hdr;
  123. rle_pixel **scanp;
  124. {
  125.     int i;
  126.  
  127.     if ( the_hdr->alpha )
  128.     scanp--;
  129.     for ( i = 0; i < the_hdr->ncolors + the_hdr->alpha; i++ )
  130.     if ( scanp[i] != 0 )
  131.     {
  132.         free( (char *)scanp[i] );
  133.         break;
  134.     }
  135.     free( (char *)scanp );
  136. }
  137.